package com.hopu.oa.service.file;


import com.hopu.oa.dao.file.FileListDao;
import com.hopu.oa.dao.file.FilePathDao;
import com.hopu.oa.entity.file.FileList;
import com.hopu.oa.entity.file.FilePath;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Secret
 * @create 2021-07-26 下午 08:06
 */
@Service
public class FileService {
    @Autowired
    private FilePathDao filePathDao;
    @Autowired
    private FileListDao fileListDao;


    /**
     * 根据文件路径 递归查询父级目录
     *
     * @param filePath
     * @param parentpaths
     */
    public void findAllParent(FilePath filePath, List<FilePath> parentpaths) {
        if (filePath.getParentId() != 1) {
            FilePath filepath1 = filePathDao.findAllParent(filePath.getParentId());
            parentpaths.add(filepath1);
            findAllParent(filepath1, parentpaths);
        }
    }

    /**
     * 根据父	ID 查询 显示的 路径
     *
     * @param parentId
     * @return
     */
    public List<FilePath> findpathByparent(int parentId) {
        return filePathDao.findByParentIdAndPathIstrash(parentId);
    }

    /**
     * 根据路径查询 文件集合
     *
     * @param filePath
     * @return
     */
    public List<FileList> findfileBypath(FilePath filePath) {
        return filePathDao.findByFpathAndFileIstrash(filePath.getPathId());
    }

    public void doshare(List<Integer> fileids) {
        for (Integer fileid : fileids) {

//            FileList filelist = fldao.findOne(fileid);
            FileList filelist = fileListDao.selectById(fileid);

            filelist.setFileIsshare(1);
//            fldao.save(filelist);
            fileListDao.updateById(filelist);
        }

    }

    /**
     * 重命名业务方法
     *
     * @param name
     * @param renamefp
     * @param nowpathid
     * @param isfile
     */
    public void rename(String name, Integer renamefp, Integer nowpathid, boolean isfile) {
        if (isfile) {
            //文件名修改
            FileList fl = fileListDao.selectById(renamefp);
            String newname = name + "." + fl.getFileShuffix();
            fl.setFileName(newname);
            fileListDao.updateById(fl);
        } else {
            //文件夹名修改
            FilePath fp = filePathDao.selectById(renamefp);
            FilePath filepath = filePathDao.selectById(nowpathid);
            fp.setPathName(name);
            filePathDao.updateById(fp);
        }

    }


    /**
     * 根据文件id 将文件放入回收站
     *
     * @param fileids
     */
    public void trashfile(List<Integer> fileids, Integer setistrashhowmany, Integer userid) {
        for (Integer fileid : fileids) {
            FileList fileList = fileListDao.selectById(fileid);
            fileList.setFileIstrash(setistrashhowmany);
            if (userid != null) {
                fileList.setFilePath(null);
            }

            fileListDao.updateById(fileList);
        }

    }

    /**
     * 根据文件夹id 批量放入回收战
     *
     * @param pathids
     */
    public void trashpath(List<Integer> pathids, Integer setistrashhaomany, boolean isfirst) {
        for (Integer pathid : pathids) {
            FilePath filepath = filePathDao.selectById(pathid);
            //System.out.println("第一个文件夹："+filepath);

            //首先将此文件夹下的文件放入回收战
            List<FileList> files = fileListDao.findByFilePath(pathid);
            if (!files.isEmpty()) {
                //	System.out.println("找到第一个文件夹下的文件不为空！~~~");
                //System.out.println(files);
                List<Integer> fileids = new ArrayList<>();
                for (FileList filelist : files) {
                    fileids.add(filelist.getFileId());
                }
                trashfile(fileids, 2, null);
            }
//			System.out.println("此文件夹内的文件修改成功");
            //然后将此文件夹下的文件夹放入回收战
            List<FilePath> filepaths = filePathDao.findPathByParentId(pathid);
            if (!filepaths.isEmpty()) {
//				System.out.println("此文件夹下还有文件夹");
                List<Integer> pathids2 = new ArrayList<>();
                for (FilePath filePath : filepaths) {
                    pathids2.add(filePath.getPathId());
                }
//				System.out.println("pathids2"+pathids2);
//				System.out.println("接下来尽心递归调用");
                trashpath(pathids2, 2, false);
            }
//			System.out.println("此文件下下再无文件夹");
            if (isfirst) {
                filepath.setParentId(0);
            }
            filepath.setPathIstrash(setistrashhaomany);
            filePathDao.updateById(filepath);
        }
    }


    /**
     * 文件还原
     *
     * @param checkfileids
     */

    public void filereturnback(List<Integer> checkfileids, Integer userid) {
        FilePath fpath = filePathDao.findByParentIdAndPathUserId(1, userid);
        for (Integer checkfileid : checkfileids) {
//            FileList fileList = fldao.findOne(checkfileid);
            FileList fileList = fileListDao.selectById(checkfileid);

            if (userid != null) {
//                String name = fileServices.onlyname(fileList.getFileName(), fpath, fileList.getFileShuffix(), 1, true);
//                fileList.setFpath(fpath);
                fileList.setFilePath(fileList.getFilePath());
                fileList.setFileName(fileList.getFileName());
            }
            fileList.setFileIstrash(0);
//            fldao.save(fileList);
            fileListDao.updateById(fileList);
        }

    }

    /**
     * 文件夹还原
     */

    public void pathreturnback(List<Integer> pathids, Integer userid) {
        for (Integer pathid : pathids) {
//            FilePath filepath = fpdao.findOne(pathid);
            FilePath filepath = filePathDao.selectById(pathid);
            System.out.println("第一个文件夹：" + filepath);

            //首先将此文件夹下的文件还原
//            List<FileList> files = fldao.findByFpath(filepath);
            List<FileList> files = fileListDao.findByPathId(filepath.getPathId());
            if (!files.isEmpty()) {
                System.out.println("找到第一个文件夹下的文件不为空！~~~");
                System.out.println(files);
                List<Integer> fileids = new ArrayList<>();
                for (FileList filelist : files) {
                    fileids.add(filelist.getFileId());
                }
                filereturnback(fileids, null);
            }
            System.out.println("此文件夹内的文件还原成功");
            System.out.println("然后将此文件夹下的文件夹还原");
            //然后将此文件夹下的文件夹还原
//            List<FilePath> filepaths = fpdao.findByParentId(pathid);
            List<FilePath> filepaths = filePathDao.findPathByParentId(pathid);
            if (!filepaths.isEmpty()) {
                System.out.println("此文件夹下还有文件夹");
                List<Integer> pathids2 = new ArrayList<>();
                for (FilePath filePath : filepaths) {
                    pathids2.add(filePath.getPathId());
                }
                System.out.println("pathids2" + pathids2);
                System.out.println("接下来尽心递归调用");
                pathreturnback(pathids2, null);
            }
            System.out.println("此文件夹下再无文件夹");

            if (userid != null) {
                int count = 0;
                System.out.println("userid不为空表示是第一次进入的文件夹 现在还原");
//                FilePath fpath = fpdao.findByParentIdAndPathUserId(1L, userid);
                FilePath fpath = filePathDao.findByParentIdAndPathUserId(1, userid);
//                String name = onlyname(filepath.getPathName(), fpath, null, 1, false);
                filepath.setPathName(filepath.getPathName());
                filepath.setParentId(fpath.getPathId());
            }
            System.out.println("还原成功");

            filepath.setPathIstrash(0);
//            fpdao.save(filepath);
            filePathDao.updateById(filepath);
        }
    }

    /**
     * 根据文件id 批量 删除文件  同时删除 数据库以及本地文件
     *
     * @param fileids
     */
    @Transactional
    public void deleteFile(List<Integer> fileids) {
        for (Integer fileid : fileids) {
            FileList filelist = fileListDao.selectById(fileid);
            System.out.println("现在删除" + filelist.getFileName() + "数据库存档>>>>>>>>>");
            fileListDao.deleteById(fileid);
        }
    }


    /**
     * 根据文件夹id 批量删除 文件夹    并删除此路径下的所有文件以及文件夹
     *
     * @param pathids
     */
    @Transactional
    public void deletePath(List<Integer> pathids) {
        for (Integer pathid : pathids) {
//            FilePath filepath = fpdao.findOne(pathid);
            FilePath filepath = filePathDao.selectById(pathid);
//			System.out.println("第一个文件夹："+filepath);

            //首先删除此文件夹下的文件
//            List<FileList> files = fldao.findByFpath(filepath);
            List<FileList> files = fileListDao.findByPathId(filepath.getPathId());
            if (!files.isEmpty()) {
//				System.out.println("找到第一个文件夹下的文件不为空！~~~");
//				System.out.println(files);
                List<Integer> fileids = new ArrayList<>();
                for (FileList filelist : files) {
                    fileids.add(filelist.getFileId());
                }
                deleteFile(fileids);
            }

            //然后删除此文件夹下的文件夹
//            List<FilePath> filepaths = fpdao.findByParentId(pathid);
            List<FilePath> filepaths = filePathDao.findPathByParentId(pathid);
            if (!filepaths.isEmpty()) {
                List<Integer> pathids2 = new ArrayList<>();
                for (FilePath filePath : filepaths) {
                    pathids2.add(filePath.getPathId());
                }
                deletePath(pathids2);
            }

//            fpdao.delete(filepath);
            filePathDao.deleteById(filepath);
        }


    }


}


